Namespace definitions

Global namespace containing types and functions accessible without any namespace prefix.

Types

A data type that represents large integers with high precision, capable of handling very large numbers. Uses java.math.BigInteger internally.

boolean

type boolean

A simple data type that represents two values: true and false.

byte_array

type byte_array : iterable<integer>

An array of bytes. This type is immutable.

collection

hidden abstract type collection<T> : iterable<T>

comparable

hidden abstract type comparable

decimal

type decimal

A data type for representing real numbers with high precision. Uses java.math.BigDecimal internally.

entity

hidden abstract type entity

Common parent type of all entity types. An entity is a data structure that reside in the SQL database.

enum

hidden abstract type enum

gtv

type gtv

Generic Transfer Value (GTV) is a general-purpose type for sending and decoding any data structure.

gtx_operation

struct gtx_operation

gtx_transaction

struct gtx_transaction

gtx_transaction_body

struct gtx_transaction_body

GTXValue

alias ~~GTXValue~~ = gtv

Generic Transfer Value (GTV) is a general-purpose type for sending and decoding any data structure.

Alias

gtv

immutable

hidden abstract type immutable

immutable_mirror_struct

hidden abstract type immutable_mirror_struct<T> : mirror_struct<T>

integer

type integer

Represents a 64-bit signed integer

iterable

hidden abstract type iterable<T>

json

type json

Wrapper object for a JSON-string.

list

type list<T> : collection<T>

Represents a mutable array list.

map

type map<K: -immutable, V> : iterable<(K, V)>

Represents a mutable map that preserves entry iteration order.

map_entry

hidden type map_entry<K, V>

A parent type for all two-element tuples (with named and unnamed fields). Is used for iterating through maps and constructing maps from iterables

mirror_struct

hidden abstract type mirror_struct<T>

mutable_mirror_struct

hidden abstract type mutable_mirror_struct<T> : mirror_struct<T>

name

alias name = text

An immutable data type for representing character strings.

Alias

text

null_ext

hidden abstract type null_ext

object

hidden abstract type object

operation

hidden abstract type operation

pubkey

alias pubkey = byte_array

An array of bytes. This type is immutable.

Alias

byte_array

range

type range : iterable<integer>

An integer range of values

rowid

type rowid

The primary key of a database record, a 64-bit integer.

set

type set<T: -immutable> : collection<T>

Represents a mutable set of elements. The set is a hash-set with an iteration order determined by the order the elements was first added to the set.

struct

hidden abstract type struct

text

type text

An immutable data type for representing character strings.

timestamp

alias timestamp = integer

Represents a 64-bit signed integer

Alias

integer

unit

type unit

virtual

hidden type virtual<T>

virtual_collection

hidden abstract type virtual_collection<T> : iterable<T>

virtual_list

hidden type virtual_list<T, T2> : virtual_collection<T2>

virtual_map

hidden type virtual_map<K: -immutable, V0, V> : iterable<(K, V)>

virtual_set

hidden type virtual_set<T: -immutable, T2> : virtual_collection<T2>

Functions

abs

function abs(a: big_integer): big_integer

Gets the absolute value of a big_integer.

function abs(a: decimal): decimal

Gets the absolute value of a decimal.

function abs(a: integer): integer

Gets the absolute value of a integer.

assert_equals

(alias) function <T> assert_equals(actual: T, expected: T)

Asserts that two values are equal.

Alias

rell.test.assert_equals

assert_events

(alias) function assert_events(expected: (text, gtv)...)

Asserts that the expected events has been emitted during last block

Alias

rell.test.assert_events

assert_fails

(alias) function <T> assert_fails(fn: () -> T): rell.test.failure

Asserts that a function fails to evaluate

Alias

rell.test.assert_fails

(alias) function <T> assert_fails(expected_message: text, fn: () -> T): rell.test.failure

Asserts that a function fails with an expected message

Alias

rell.test.assert_fails

assert_false

(alias) function assert_false(actual: boolean)

Asserts that the value is false.

Alias

rell.test.assert_false

assert_ge

(alias) function <T: -comparable> assert_ge(actual: T, expected: T)

Asserts that the value is greater than or equal to the expected value

Alias

rell.test.assert_ge

assert_ge_le

(alias) function <T: -comparable> assert_ge_le(actual: T, expected1: T, expected2: T)

Asserts that the value is greater than or equal to the first value and less than or equal to the second value.

Alias

rell.test.assert_ge_le

assert_ge_lt

(alias) function <T: -comparable> assert_ge_lt(actual: T, expected1: T, expected2: T)

Asserts that the value is greater than or equal to the first value and less than the second value.

Alias

rell.test.assert_ge_lt

assert_gt

(alias) function <T: -comparable> assert_gt(actual: T, expected: T)

Asserts that the value is greater than the expected value

Alias

rell.test.assert_gt

assert_gt_le

(alias) function <T: -comparable> assert_gt_le(actual: T, expected1: T, expected2: T)

Asserts that the value is greater than the first value and less than or equal to the second value.

Alias

rell.test.assert_gt_le

assert_gt_lt

(alias) function <T: -comparable> assert_gt_lt(actual: T, expected1: T, expected2: T)

Asserts that the value is greater than the first value and less than the second value.

Alias

rell.test.assert_gt_lt

assert_le

(alias) function <T: -comparable> assert_le(actual: T, expected: T)

Asserts that the value is less than or equal to the expected value

Alias

rell.test.assert_le

assert_lt

(alias) function <T: -comparable> assert_lt(actual: T, expected: T)

Asserts that the value is less than the expected value

Alias

rell.test.assert_lt

assert_not_equals

(alias) function <T> assert_not_equals(actual: T, illegal: T)

Asserts that two values are not equal.

Alias

rell.test.assert_not_equals

assert_not_null

(alias) function <T: -any> assert_not_null(actual: T?)

Asserts that the value is not null.

Alias

rell.test.assert_not_null

assert_null

(alias) function assert_null(actual: anything)

Asserts that the value is null.

Alias

rell.test.assert_null

assert_true

(alias) function assert_true(actual: boolean)

Asserts that the value is true.

Alias

rell.test.assert_true

empty

function <T> empty(arg: T?): boolean

Checks if the value is null or empty.

eth_ecrecover

(alias) function eth_ecrecover(r: byte_array, s: byte_array, rec_id: integer, data_hash: byte_array): byte_array

Calculates an Ethereum public key from a signature and hash.

Alias

crypto.eth_ecrecover

exists

function <T> exists(arg: T?): boolean

Checks if the value is null or empty.

is_signer

function ~~is_signer~~(pubkey: byte_array): boolean

keccak256

(alias) function keccak256(input: byte_array): byte_array

Calculates a Keccak256 hash of a byte array and returns a byte array.

Alias

crypto.keccak256

log

function log(values: anything...)

Prints the given message to the node log with timestamp

max

function max(a: big_integer, b: big_integer): big_integer

Identifies the larger of two big_integer values.

function max(a: decimal, b: decimal): decimal

Identifies the larger of two decimal values.

function max(a: integer, b: integer): integer

Identifies the larger of two integer values.

min

function min(a: big_integer, b: big_integer): big_integer

Determines the smaller of two big_integer values.

function min(a: decimal, b: decimal): decimal

Determines the smaller of two decimal values.

function min(a: integer, b: integer): integer

Determines the smaller of two integer values.

function print(values: anything...)

Prints the given message to the node log

require

function <T: -any> require(value: T?, message: text): T

Checks for null values and throws an exception if null.

function require(value: boolean, message: text)

Checks a boolean condition and throws an exception if false.

require_not_empty

function <T: -any> require_not_empty(value: T?, message: text): T

Checks for precence of a value and throws an exception if null.

function <T> require_not_empty(value: list<T>?, message: text): list<T>

Checks for empty list and throws an exception if empty.

function <K: -immutable, V> require_not_empty(value: map<K, V>?, message: text): map<K, V>

Checks for empty map and throws an exception if empty.

function <T: -immutable> require_not_empty(value: set<T>?, message: text): set<T>

Checks for empty set and throws an exception if empty.

requireNotEmpty

(alias) function <T: -any> ~~requireNotEmpty~~(value: T?, message: text): T

Checks for precence of a value and throws an exception if null.

Alias

require_not_empty

(alias) function <T> ~~requireNotEmpty~~(value: list<T>?, message: text): list<T>

Checks for empty list and throws an exception if empty.

Alias

require_not_empty

(alias) function <K: -immutable, V> ~~requireNotEmpty~~(value: map<K, V>?, message: text): map<K, V>

Checks for empty map and throws an exception if empty.

Alias

require_not_empty

(alias) function <T: -immutable> ~~requireNotEmpty~~(value: set<T>?, message: text): set<T>

Checks for empty set and throws an exception if empty.

Alias

require_not_empty

sha256

(alias) function sha256(input: byte_array): byte_array

Calculates an SHA-256 hash of a byte array and returns a byte array.

Alias

crypto.sha256

try_call

function <T> try_call(fn: () -> T): T?

Calls a function and handles exceptions gracefully, returning null if an exception occurs.

function try_call(fn: () -> unit): boolean

Calls a function that doesn't return a value and handles exceptions gracefully.

function <T> try_call(fn: () -> T, default: T): T

Calls a function and handles exceptions gracefully, providing a fallback value if an exception occurs.

verify_signature

(alias) function verify_signature(data_hash: byte_array, pubkey: byte_array, signature: byte_array): boolean

Verifies a signature against a message and public key.

Alias

crypto.verify_signature